goodnesskay / LARAVEL-PDF-VIEWER

(function pdfjsWrapper() {

  // Use strict in our context only - users might not want it

  'use strict';

/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

/* Copyright 2012 Mozilla Foundation

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* globals Cmd, ColorSpace, Dict, MozBlobBuilder, Name, PDFJS, Ref, URL,

           Promise */

'use strict';

var globalScope = (typeof window === 'undefined') ? this : window;

var isWorker = (typeof window === 'undefined');

var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];

var TextRenderingMode = {

  FILL: 0,

  STROKE: 1,

  FILL_STROKE: 2,

  INVISIBLE: 3,

  FILL_ADD_TO_PATH: 4,

  STROKE_ADD_TO_PATH: 5,

  FILL_STROKE_ADD_TO_PATH: 6,

  ADD_TO_PATH: 7,

  FILL_STROKE_MASK: 3,

  ADD_TO_PATH_FLAG: 4

};

var ImageKind = {

  GRAYSCALE_1BPP: 1,

  RGB_24BPP: 2,

  RGBA_32BPP: 3

};

  WIDGET: 1,

  TEXT: 2,

  LINK: 3

};

  UNKNOWN: 0,

  FLATE: 1,

  LZW: 2,

  DCT: 3,

  JPX: 4,

  JBIG: 5,

  A85: 6,

  AHX: 7,

  CCF: 8,

  RL: 9

};

  UNKNOWN: 0,

  TYPE1: 1,

  TYPE1C: 2,

  CIDFONTTYPE0: 3,

  CIDFONTTYPE0C: 4,

  TRUETYPE: 5,

  CIDFONTTYPE2: 6,

  TYPE3: 7,

  OPENTYPE: 8,

  TYPE0: 9,

  MMTYPE1: 10

};

// The global PDFJS object exposes the API

// In production, it will be declared outside a global wrapper

// In development, it will be declared here

if (!globalScope.PDFJS) {

  globalScope.PDFJS = {};

}

globalScope.PDFJS.pdfBug = false;

PDFJS.VERBOSITY_LEVELS = {

  errors: 0,

  warnings: 1,

  infos: 5

};

// All the possible operations for an operator list.

var OPS = PDFJS.OPS = {

  // Intentionally start from 1 so it is easy to spot bad operators that will be

  // 0's.

  dependency: 1,

  setLineWidth: 2,

  setLineCap: 3,

  setLineJoin: 4,

  setMiterLimit: 5,

  setDash: 6,

  setRenderingIntent: 7,

  setFlatness: 8,

  setGState: 9,

  save: 10,

  restore: 11,

  transform: 12,

  moveTo: 13,

  lineTo: 14,

  curveTo: 15,

  curveTo2: 16,

  curveTo3: 17,

  closePath: 18,

  rectangle: 19,

  stroke: 20,

  closeStroke: 21,

  fill: 22,

  eoFill: 23,

  fillStroke: 24,

  eoFillStroke: 25,

  closeFillStroke: 26,

  closeEOFillStroke: 27,

  endPath: 28,

  clip: 29,

  eoClip: 30,

  beginText: 31,

  endText: 32,

  setCharSpacing: 33,

  setWordSpacing: 34,

  setHScale: 35,

  setLeading: 36,

  setFont: 37,

  setTextRenderingMode: 38,

  setTextRise: 39,

  moveText: 40,

  setLeadingMoveText: 41,

  setTextMatrix: 42,

  nextLine: 43,

  showText: 44,

  showSpacedText: 45,

  nextLineShowText: 46,

  nextLineSetSpacingShowText: 47,

  setCharWidth: 48,

  setCharWidthAndBounds: 49,

  setStrokeColorSpace: 50,

  setFillColorSpace: 51,

  setStrokeColor: 52,

  setStrokeColorN: 53,

  setFillColor: 54,

  setFillColorN: 55,

  setStrokeGray: 56,

  setFillGray: 57,

  setStrokeRGBColor: 58,

  setFillRGBColor: 59,

  setStrokeCMYKColor: 60,

  setFillCMYKColor: 61,

  shadingFill: 62,

  beginInlineImage: 63,

  beginImageData: 64,

  endInlineImage: 65,

  paintXObject: 66,

  markPoint: 67,

  markPointProps: 68,

  beginMarkedContent: 69,

  beginMarkedContentProps: 70,

  endMarkedContent: 71,

  beginCompat: 72,

  endCompat: 73,

  paintFormXObjectBegin: 74,

  paintFormXObjectEnd: 75,

  beginGroup: 76,

  endGroup: 77,

  beginAnnotations: 78,

  endAnnotations: 79,

  beginAnnotation: 80,

  endAnnotation: 81,

  paintJpegXObject: 82,

  paintImageMaskXObject: 83,

  paintImageMaskXObjectGroup: 84,

  paintImageXObject: 85,

  paintInlineImageXObject: 86,

  paintInlineImageXObjectGroup: 87,

  paintImageXObjectRepeat: 88,

  paintImageMaskXObjectRepeat: 89,

  paintSolidColorImageMask: 90,

  constructPath: 91

};

// A notice for devs. These are good for things that are helpful to devs, such

// as warning that Workers were disabled, which is important to devs but not

// end users.

function info(msg) {

  if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.infos) {

  }

}

// Non-fatal warnings.

function warn(msg) {

  if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.warnings) {

  }

}

// Fatal errors that should trigger the fallback UI and halt execution by

// throwing an exception.

function error(msg) {

  if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.errors) {

    console.log(backtrace());

  }

  UnsupportedManager.notify(UNSUPPORTED_FEATURES.unknown);

  throw new Error(msg);

}

function backtrace() {

  try {

    throw new Error();

  } catch (e) {

    return e.stack ? e.stack.split('\n').slice(2).join('\n') : '';

  }

}

function assert(cond, msg) {

  if (!cond) {

    error(msg);

  }

}

var UNSUPPORTED_FEATURES = PDFJS.UNSUPPORTED_FEATURES = {

  unknown: 'unknown',

  forms: 'forms',

  javaScript: 'javaScript',

  smask: 'smask',

  shadingPattern: 'shadingPattern',

  font: 'font'

};

var UnsupportedManager = PDFJS.UnsupportedManager =

  (function UnsupportedManagerClosure() {

  var listeners = [];

  return {

    listen: function (cb) {

      listeners.push(cb);

    },

    notify: function (featureId) {

      warn('Unsupported feature "' + featureId + '"');

      for (var i = 0, ii = listeners.length; i < ii; i++) {

        listeners[i](featureId);

      }

    }

  };

})();

// Combines two URLs. The baseUrl shall be absolute URL. If the url is an

// absolute URL, it will be returned as is.

function combineUrl(baseUrl, url) {

  if (!url) {

    return baseUrl;

  }

  if (/^[a-z][a-z0-9+\-.]*:/i.test(url)) {

    return url;

  }

  var i;

  if (url.charAt(0) === '/') {

    // absolute path

    i = baseUrl.indexOf('://');

    if (url.charAt(1) === '/') {

      ++i;

    } else {

      i = baseUrl.indexOf('/', i + 3);

    }

    return baseUrl.substring(0, i) + url;

  } else {

    // relative path

    var pathLength = baseUrl.length;

    i = baseUrl.lastIndexOf('#');

    pathLength = i >= 0 ? i : pathLength;

    i = baseUrl.lastIndexOf('?', pathLength);

    pathLength = i >= 0 ? i : pathLength;

    var prefixLength = baseUrl.lastIndexOf('/', pathLength);

    return baseUrl.substring(0, prefixLength + 1) + url;

  }

}

// Validates if URL is safe and allowed, e.g. to avoid XSS.

function isValidUrl(url, allowRelative) {

  if (!url) {

    return false;

  }

  // RFC 3986 (http://tools.ietf.org/html/rfc3986#section-3.1)

  // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

  var protocol = /^[a-z][a-z0-9+\-.]*(?=:)/i.exec(url);

  if (!protocol) {

    return allowRelative;

  }

  protocol = protocol[0].toLowerCase();

  switch (protocol) {

    case 'http':

    case 'https':

    case 'ftp':

    case 'mailto':

    case 'tel':

      return true;

    default:

      return false;

  }

}

PDFJS.isValidUrl = isValidUrl;

function shadow(obj, prop, value) {

  Object.defineProperty(obj, prop, { value: value,

                                     enumerable: true,

                                     configurable: true,

                                     writable: false });

  return value;

}

PDFJS.shadow = shadow;

var PasswordResponses = PDFJS.PasswordResponses = {

  NEED_PASSWORD: 1,

  INCORRECT_PASSWORD: 2

};

var PasswordException = (function PasswordExceptionClosure() {

  function PasswordException(msg, code) {

    this.name = 'PasswordException';

    this.message = msg;

    this.code = code;

  }

  PasswordException.prototype = new Error();

  PasswordException.constructor = PasswordException;

  return PasswordException;

})();

PDFJS.PasswordException = PasswordException;

var UnknownErrorException = (function UnknownErrorExceptionClosure() {

  function UnknownErrorException(msg, details) {

    this.name = 'UnknownErrorException';

    this.message = msg;

    this.details = details;

  }

  UnknownErrorException.prototype = new Error();

  UnknownErrorException.constructor = UnknownErrorException;

  return UnknownErrorException;

})();

PDFJS.UnknownErrorException = UnknownErrorException;

var InvalidPDFException = (function InvalidPDFExceptionClosure() {

  function InvalidPDFException(msg) {

    this.name = 'InvalidPDFException';

    this.message = msg;

  }

  InvalidPDFException.prototype = new Error();

  InvalidPDFException.constructor = InvalidPDFException;

  return InvalidPDFException;

})();

PDFJS.InvalidPDFException = InvalidPDFException;

var MissingPDFException = (function MissingPDFExceptionClosure() {

  function MissingPDFException(msg) {

    this.name = 'MissingPDFException';

    this.message = msg;

  }

  MissingPDFException.prototype = new Error();

  MissingPDFException.constructor = MissingPDFException;

  return MissingPDFException;

})();

PDFJS.MissingPDFException = MissingPDFException;

var UnexpectedResponseException =

    (function UnexpectedResponseExceptionClosure() {

  function UnexpectedResponseException(msg, status) {

    this.name = 'UnexpectedResponseException';

    this.message = msg;

    this.status = status;

  }

  UnexpectedResponseException.prototype = new Error();

  UnexpectedResponseException.constructor = UnexpectedResponseException;

  return UnexpectedResponseException;

})();

PDFJS.UnexpectedResponseException = UnexpectedResponseException;

  function NotImplementedException(msg) {

    this.message = msg;

  }

  NotImplementedException.prototype = new Error();

  NotImplementedException.prototype.name = 'NotImplementedException';

  NotImplementedException.constructor = NotImplementedException;

  return NotImplementedException;

})();

  function MissingDataException(begin, end) {

    this.begin = begin;

    this.end = end;

    this.message = 'Missing data [' + begin + ', ' + end + ')';

  }

  MissingDataException.prototype = new Error();

  MissingDataException.prototype.name = 'MissingDataException';

  MissingDataException.constructor = MissingDataException;

  return MissingDataException;

})();

  function XRefParseException(msg) {

    this.message = msg;

  }

  XRefParseException.prototype = new Error();

  XRefParseException.prototype.name = 'XRefParseException';

  XRefParseException.constructor = XRefParseException;

  return XRefParseException;

})();

function bytesToString(bytes) {

  assert(bytes !== null && typeof bytes === 'object' &&

         bytes.length !== undefined, 'Invalid argument for bytesToString');

  var length = bytes.length;

  var MAX_ARGUMENT_COUNT = 8192;

  if (length < MAX_ARGUMENT_COUNT) {

    return String.fromCharCode.apply(null, bytes);

  }

  var strBuf = [];

  for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {

    var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);

    var chunk = bytes.subarray(i, chunkEnd);

    strBuf.push(String.fromCharCode.apply(null, chunk));

  }

  return strBuf.join('');

}

function stringToBytes(str) {

  assert(typeof str === 'string', 'Invalid argument for stringToBytes');

  var length = str.length;

  var bytes = new Uint8Array(length);

  for (var i = 0; i < length; ++i) {

    bytes[i] = str.charCodeAt(i) & 0xFF;

  }

  return bytes;

}

function string32(value) {

  return String.fromCharCode((value >> 24) & 0xff, (value >> 16) & 0xff,

                             (value >> 8) & 0xff, value & 0xff);

}

  var n = 1, i = 0;

  while (x > n) {

    n <<= 1;

    i++;

  }

  return i;

}

  return (data[start] << 24) >> 24;

}

  return (data[offset] << 8) | data[offset + 1];

}

  return ((data[offset] << 24) | (data[offset + 1] << 16) |

         (data[offset + 2] << 8) | data[offset + 3]) >>> 0;

}

// Lazy test the endianness of the platform

// NOTE: This will be 'true' for simulated TypedArrays

function isLittleEndian() {

  var buffer8 = new Uint8Array(2);

  buffer8[0] = 1;

  var buffer16 = new Uint16Array(buffer8.buffer);

  return (buffer16[0] === 1);

}

Object.defineProperty(PDFJS, 'isLittleEndian', {

  configurable: true,

  get: function PDFJS_isLittleEndian() {

    return shadow(PDFJS, 'isLittleEndian', isLittleEndian());

  }

});

//#if !(FIREFOX || MOZCENTRAL || B2G || CHROME)

//// Lazy test if the userAgant support CanvasTypedArrays

function hasCanvasTypedArrays() {

  var canvas = document.createElement('canvas');

  canvas.width = canvas.height = 1;

  var ctx = canvas.getContext('2d');

  var imageData = ctx.createImageData(1, 1);

  return (typeof imageData.data.buffer !== 'undefined');

}

Object.defineProperty(PDFJS, 'hasCanvasTypedArrays', {

  configurable: true,

  get: function PDFJS_hasCanvasTypedArrays() {

    return shadow(PDFJS, 'hasCanvasTypedArrays', hasCanvasTypedArrays());

  }

});

var Uint32ArrayView = (function Uint32ArrayViewClosure() {

  function Uint32ArrayView(buffer, length) {

    this.buffer = buffer;

    this.byteLength = buffer.length;

    this.length = length === undefined ? (this.byteLength >> 2) : length;

    ensureUint32ArrayViewProps(this.length);

  }

  Uint32ArrayView.prototype = Object.create(null);

  var uint32ArrayViewSetters = 0;

  function createUint32ArrayProp(index) {

    return {

      get: function () {

        var buffer = this.buffer, offset = index << 2;

        return (buffer[offset] | (buffer[offset + 1] << 8) |

          (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24)) >>> 0;

      },

      set: function (value) {

        var buffer = this.buffer, offset = index << 2;

        buffer[offset] = value & 255;

        buffer[offset + 1] = (value >> 8) & 255;

        buffer[offset + 2] = (value >> 16) & 255;

        buffer[offset + 3] = (value >>> 24) & 255;

      }

    };

  }

  function ensureUint32ArrayViewProps(length) {

      Object.defineProperty(Uint32ArrayView.prototype,

        uint32ArrayViewSetters,

        createUint32ArrayProp(uint32ArrayViewSetters));

      uint32ArrayViewSetters++;

    }

  }

  return Uint32ArrayView;

})();

//#else

//PDFJS.hasCanvasTypedArrays = true;

//#endif

var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];

var Util = PDFJS.Util = (function UtilClosure() {

  function Util() {}

  var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];

  // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids

  // creating many intermediate strings.

  Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {

    rgbBuf[1] = r;

    rgbBuf[3] = g;

    rgbBuf[5] = b;

    return rgbBuf.join('');

  };

  // Concatenates two transformation matrices together and returns the result.

  Util.transform = function Util_transform(m1, m2) {

    return [

      m1[0] * m2[0] + m1[2] * m2[1],

      m1[1] * m2[0] + m1[3] * m2[1],

      m1[0] * m2[2] + m1[2] * m2[3],

      m1[1] * m2[2] + m1[3] * m2[3],

      m1[0] * m2[4] + m1[2] * m2[5] + m1[4],

      m1[1] * m2[4] + m1[3] * m2[5] + m1[5]

    ];

  };

  // For 2d affine transforms

  Util.applyTransform = function Util_applyTransform(p, m) {

    var xt = p[0] * m[0] + p[1] * m[2] + m[4];

    var yt = p[0] * m[1] + p[1] * m[3] + m[5];

    return [xt, yt];

  };

  Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {

    var d = m[0] * m[3] - m[1] * m[2];

    var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;

    var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;

    return [xt, yt];

  };

  // Applies the transform to the rectangle and finds the minimum axially

  // aligned bounding box.

  Util.getAxialAlignedBoundingBox =

    function Util_getAxialAlignedBoundingBox(r, m) {

    var p1 = Util.applyTransform(r, m);

    var p2 = Util.applyTransform(r.slice(2, 4), m);

    var p3 = Util.applyTransform([r[0], r[3]], m);

    var p4 = Util.applyTransform([r[2], r[1]], m);

    return [

      Math.min(p1[0], p2[0], p3[0], p4[0]),

      Math.min(p1[1], p2[1], p3[1], p4[1]),

      Math.max(p1[0], p2[0], p3[0], p4[0]),

      Math.max(p1[1], p2[1], p3[1], p4[1])

    ];

  };

  Util.inverseTransform = function Util_inverseTransform(m) {

    var d = m[0] * m[3] - m[1] * m[2];

    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d,

      (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];

  };

  // Apply a generic 3d matrix M on a 3-vector v:

  //   | a b c |   | X |

  //   | d e f | x | Y |

  //   | g h i |   | Z |

  // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],

  // with v as [X,Y,Z]

  Util.apply3dTransform = function Util_apply3dTransform(m, v) {

    return [

      m[0] * v[0] + m[1] * v[1] + m[2] * v[2],

      m[3] * v[0] + m[4] * v[1] + m[5] * v[2],

      m[6] * v[0] + m[7] * v[1] + m[8] * v[2]

    ];

  };

  // This calculation uses Singular Value Decomposition.

  // The SVD can be represented with formula A = USV. We are interested in the

  // matrix S here because it represents the scale values.

  Util.singularValueDecompose2dScale =

    function Util_singularValueDecompose2dScale(m) {

    var transpose = [m[0], m[2], m[1], m[3]];

    // Multiply matrix m with its transpose.

    var a = m[0] * transpose[0] + m[1] * transpose[2];

    var b = m[0] * transpose[1] + m[1] * transpose[3];

    var c = m[2] * transpose[0] + m[3] * transpose[2];

    var d = m[2] * transpose[1] + m[3] * transpose[3];

    // Solve the second degree polynomial to get roots.

    var first = (a + d) / 2;

    var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;

    var sx = first + second || 1;

    var sy = first - second || 1;

    // Scale values are the square roots of the eigenvalues.

    return [Math.sqrt(sx), Math.sqrt(sy)];

  };

  // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)

  // For coordinate systems whose origin lies in the bottom-left, this

  // means normalization to (BL,TR) ordering. For systems with origin in the

  // top-left, this means (TL,BR) ordering.

  Util.normalizeRect = function Util_normalizeRect(rect) {

    var r = rect.slice(0); // clone rect

    if (rect[0] > rect[2]) {

      r[0] = rect[2];

      r[2] = rect[0];

    }

    if (rect[1] > rect[3]) {

      r[1] = rect[3];

      r[3] = rect[1];

    }

    return r;

  };

  // Returns a rectangle [x1, y1, x2, y2] corresponding to the

  // intersection of rect1 and rect2. If no intersection, returns 'false'

  // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]

  Util.intersect = function Util_intersect(rect1, rect2) {

    function compare(a, b) {

      return a - b;

    }

    // Order points along the axes

    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),

        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),

        result = [];

    rect1 = Util.normalizeRect(rect1);

    rect2 = Util.normalizeRect(rect2);

    // X: first and second points belong to different rectangles?

    if ((orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||

        (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])) {

      // Intersection must be between second and third points

      result[0] = orderedX[1];

      result[2] = orderedX[2];

    } else {

      return false;

    }

    // Y: first and second points belong to different rectangles?

    if ((orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||

        (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])) {

      // Intersection must be between second and third points

      result[1] = orderedY[1];

      result[3] = orderedY[2];

    } else {

      return false;

    }

    return result;

  };

  Util.sign = function Util_sign(num) {

    return num < 0 ? -1 : 1;

  };

  Util.appendToArray = function Util_appendToArray(arr1, arr2) {

    Array.prototype.push.apply(arr1, arr2);

  };

  Util.prependToArray = function Util_prependToArray(arr1, arr2) {

    Array.prototype.unshift.apply(arr1, arr2);

  };

  Util.extendObj = function extendObj(obj1, obj2) {

      obj1[key] = obj2[key];

    }

  };

  Util.getInheritableProperty = function Util_getInheritableProperty(dict,

                                                                     name) {

    while (dict && !dict.has(name)) {

      dict = dict.get('Parent');

    }

    if (!dict) {

      return null;

    }

    return dict.get(name);

  };

  Util.inherit = function Util_inherit(sub, base, prototype) {

    sub.prototype = Object.create(base.prototype);

    sub.prototype.constructor = sub;

      sub.prototype[prop] = prototype[prop];

    }

  };

  Util.loadScript = function Util_loadScript(src, callback) {

    var script = document.createElement('script');

    var loaded = false;

    script.setAttribute('src', src);

    if (callback) {

      script.onload = function() {

        if (!loaded) {

          callback();

        }

        loaded = true;

      };

    }

    document.getElementsByTagName('head')[0].appendChild(script);

  };

  return Util;

})();

/**

 * PDF page viewport created based on scale, rotation and offset.

 * @class

 * @alias PDFJS.PageViewport

 */

var PageViewport = PDFJS.PageViewport = (function PageViewportClosure() {

  /**

   * @constructor

   * @private

   * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates.

   * @param scale {number} scale of the viewport.

   * @param rotation {number} rotations of the viewport in degrees.

   * @param offsetX {number} offset X

   * @param offsetY {number} offset Y

   * @param dontFlip {boolean} if true, axis Y will not be flipped.

   */

  function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {

    this.viewBox = viewBox;

    this.scale = scale;

    this.rotation = rotation;

    this.offsetX = offsetX;

    this.offsetY = offsetY;

    // creating transform to convert pdf coordinate system to the normal

    // canvas like coordinates taking in account scale and rotation

    var centerX = (viewBox[2] + viewBox[0]) / 2;

    var centerY = (viewBox[3] + viewBox[1]) / 2;

    var rotateA, rotateB, rotateC, rotateD;

    rotation = rotation % 360;

    rotation = rotation < 0 ? rotation + 360 : rotation;

    switch (rotation) {

      case 180:

        rotateA = -1; rotateB = 0; rotateC = 0; rotateD = 1;

        break;

      case 90:

        rotateA = 0; rotateB = 1; rotateC = 1; rotateD = 0;

        break;

      case 270:

        rotateA = 0; rotateB = -1; rotateC = -1; rotateD = 0;

        break;

      //case 0:

      default:

        rotateA = 1; rotateB = 0; rotateC = 0; rotateD = -1;

        break;

    }

    if (dontFlip) {

      rotateC = -rotateC; rotateD = -rotateD;

    }

    var offsetCanvasX, offsetCanvasY;

    var width, height;

    if (rotateA === 0) {

      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;

      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;

      width = Math.abs(viewBox[3] - viewBox[1]) * scale;

      height = Math.abs(viewBox[2] - viewBox[0]) * scale;

    } else {

      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;

      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;

      width = Math.abs(viewBox[2] - viewBox[0]) * scale;

      height = Math.abs(viewBox[3] - viewBox[1]) * scale;

    }

    // creating transform for the following operations:

    // translate(-centerX, -centerY), rotate and flip vertically,

    // scale, and translate(offsetCanvasX, offsetCanvasY)

    this.transform = [

      rotateA * scale,

      rotateB * scale,

      rotateC * scale,

      rotateD * scale,

      offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,

      offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY

    ];

    this.width = width;

    this.height = height;

    this.fontScale = scale;

  }

  PageViewport.prototype = /** @lends PDFJS.PageViewport.prototype */ {

    /**

     * Clones viewport with additional properties.

     * @param args {Object} (optional) If specified, may contain the 'scale' or

     * 'rotation' properties to override the corresponding properties in

     * the cloned viewport.

     * @returns {PDFJS.PageViewport} Cloned viewport.

     */

    clone: function PageViewPort_clone(args) {

      args = args || {};